/**
 * @file command_executor_system.cpp
 * @brief ESP32沙画机系统监控功能实现
 * 
 * 系统功能:
 * - 状态查询
 * - 系统信息
 * - 图案管理
 * - LED控制
 * - 帮助信息
 */

#include "command_executor.h"
#include "command_executor_debug.h"

// ==================== 系统状态查询实现 ====================

String CommandExecutor::executeStatusCommand() {
    DynamicJsonDocument statusDoc = createOptimizedJsonDoc();
    
    // 系统基本状态
    statusDoc["system_power"] = *systemPowerEnabled;
    statusDoc["drawing_active"] = *isDrawingActive;
    statusDoc["drawing_paused"] = *isDrawingPaused;
    statusDoc["stream_mode"] = *isStreamMode;
    
    if (*isDrawingPaused && *pausedAtIndex >= 0) {
        statusDoc["paused_index"] = *pausedAtIndex;
    }
    
    // 设备状态
    if (deviceStateManager) {
        statusDoc["device_state"] = getSystemStateString(deviceStateManager->getSystemState());
    }
    
    // 图案信息
    if (patternLoader) {
        String currentPattern = patternLoader->getCurrentPatternName();
        if (currentPattern.length() > 0) {
            statusDoc["current_pattern"] = currentPattern;
            statusDoc["pattern_points"] = patternLoader->getPatternSize();
        }
    }
    
    // 电机状态
    if (motionController) {
        statusDoc["motors_enabled"] = motionController->areMotorsEnabled();
        statusDoc["is_moving"] = motionController->isMovingNow();
    }
    
    // LED状态
    if (ledControlCenter) {
        statusDoc["led_status"] = (int)ledControlCenter->getCurrentStatus();
    }
    
    // 内存信息
    statusDoc["free_heap"] = ESP.getFreeHeap();
    statusDoc["min_free_heap"] = esp_get_minimum_free_heap_size();
    
    String result;
    serializeJson(statusDoc, result);
    return result;
}

String CommandExecutor::executeInfoCommand() {
    DynamicJsonDocument doc = createOptimizedJsonDoc();
    
    // 设备基本信息
    doc["chip_model"] = ESP.getChipModel();
    doc["chip_revision"] = ESP.getChipRevision();
    doc["cpu_freq_mhz"] = getCpuFrequencyMhz();
    doc["flash_size"] = ESP.getFlashChipSize();
    doc["sketch_size"] = ESP.getSketchSize();
    doc["free_sketch_space"] = ESP.getFreeSketchSpace();
    
    // 内存信息
    doc["heap_size"] = ESP.getHeapSize();
    doc["free_heap"] = ESP.getFreeHeap();
    doc["min_free_heap"] = esp_get_minimum_free_heap_size();
    doc["max_alloc_heap"] = ESP.getMaxAllocHeap();
    
    // WiFi信息
    if (wifiManager) {
        doc["wifi_connected"] = WiFi.isConnected();
        if (WiFi.isConnected()) {
            doc["wifi_ssid"] = WiFi.SSID();
            doc["wifi_rssi"] = WiFi.RSSI();
            doc["ip_address"] = WiFi.localIP().toString();
        }
    }
    
    String result;
    serializeJson(doc, result);
    return result;
}

// 统一的信息输出函数 - 使用简单的宏来避免重复的标题格式
#define PRINT_SECTION_HEADER(title) Serial.printf("=== %s ===\n", title)

int CommandExecutor::executeTaskInfoCommand() {
    PRINT_SECTION_HEADER("ESP32 任务信息");
    Serial.printf("堆栈剩余: %d bytes\n", uxTaskGetStackHighWaterMark(NULL));
    Serial.printf("运行任务数: %d\n", uxTaskGetNumberOfTasks());
    Serial.printf("最小剩余堆: %d bytes\n", esp_get_minimum_free_heap_size());
    return 0;
}

int CommandExecutor::executeCoreInfoCommand() {
    PRINT_SECTION_HEADER("ESP32 核心信息");
    Serial.printf("CPU 频率: %d MHz\n", getCpuFrequencyMhz());
    Serial.printf("芯片型号: %s\n", ESP.getChipModel());
    Serial.printf("芯片版本: %d\n", ESP.getChipRevision());
    Serial.printf("核心数量: %d\n", ESP.getChipCores());
    return 0;
}

int CommandExecutor::executeDetailedStatusCommand() {
    Serial.println("\n=== 系统详细状态 ===");
    
    // 设备状态
    if (deviceStateManager) {
        Serial.printf("设备状态: %s\n", getSystemStateString(deviceStateManager->getSystemState()).c_str());
        Serial.printf("电源状态: %s\n", *systemPowerEnabled ? "开启" : "关闭");
    }
    
    // 绘图状态
    Serial.printf("绘图活跃: %s\n", *isDrawingActive ? "是" : "否");
    Serial.printf("绘图暂停: %s\n", *isDrawingPaused ? "是" : "否");
    if (*isDrawingPaused && *pausedAtIndex >= 0) {
        Serial.printf("暂停位置: 索引 %d\n", *pausedAtIndex);
    }
    
    // 图案信息 - 避免临时String创建
    if (patternLoader) {
        const String& currentPattern = patternLoader->getCurrentPatternName();
        if (currentPattern.length() > 0) {
            Serial.printf("当前图案: %s\n", currentPattern.c_str());
            Serial.printf("图案点数: %d\n", patternLoader->getPatternSize());
        } else {
            Serial.println("当前图案: 无");
        }
    }
    
    // 电机状态
    if (motionController) {
        Serial.printf("电机启用: %s\n", motionController->areMotorsEnabled() ? "是" : "否");
        Serial.printf("正在移动: %s\n", motionController->isMovingNow() ? "是" : "否");
        Serial.printf("自动管理: %s\n", motionController->isAutoMotorManagementEnabled() ? "启用" : "禁用");
        Serial.printf("空闲超时: %lu秒\n", motionController->getMotorIdleTimeout() / 1000);
    }
    
    // LED状态
    if (ledControlCenter) {
        Serial.printf("LED状态: %s\n", getLEDStatus().c_str());
    }
    
    // 内存信息
    Serial.printf("剩余堆内存: %d bytes\n", ESP.getFreeHeap());
    Serial.printf("最小剩余堆: %d bytes\n", esp_get_minimum_free_heap_size());
    
    Serial.println("========================\n");
    return 0;
}

// ==================== 图案管理实现 ====================

std::vector<String> CommandExecutor::getPatternList() {
    if (patternLoader) {
        return patternLoader->listPatternFiles();
    }
    return std::vector<String>();
}

int CommandExecutor::loadPattern(const String& filename) {
    if (!patternLoader) {
        Serial.println("[ERROR] PatternLoader未初始化");
        return 1;
    }
    
    if (!patternLoader->isSDReady()) {
        Serial.println("[ERROR] SD卡未就绪");
        return 1;
    }
    
    if (patternLoader->loadPattern(filename)) {
        Serial.printf("[PATTERN] 图案已加载: %s\n", filename.c_str());
        // 🔧 修复：不自动重置状态，让调用者决定状态转换
        return 0;
    } else {
        Serial.printf("[ERROR] 图案加载失败: %s\n", filename.c_str());
        return 2;
    }
}

String CommandExecutor::getNextPattern() {
    if (patternLoader) {
        return patternLoader->getNextPattern();
    }
    return "";
}

String CommandExecutor::getPreviousPattern() {
    if (patternLoader) {
        return patternLoader->getPreviousPattern();
    }
    return "";
}

int CommandExecutor::loadNextPattern() {
    if (!patternLoader) {
        Serial.println("[ERROR] PatternLoader未初始化");
        return 1;
    }
    
    String nextPattern = getNextPattern();
    if (nextPattern.length() == 0) {
        Serial.println("[ERROR] 没有可用的下一个图案");
        return 1;
    }
    
    if (patternLoader->loadPattern(nextPattern)) {
        Serial.printf("[PATTERN] 下一个图案已加载: %s\n", nextPattern.c_str());
        // 🔧 修复：不自动重置状态，让调用者决定状态转换
        return 0;
    } else {
        Serial.printf("[ERROR] 下一个图案加载失败: %s\n", nextPattern.c_str());
        return 2;
    }
}

int CommandExecutor::loadPreviousPattern() {
    if (!patternLoader) {
        Serial.println("[ERROR] PatternLoader未初始化");
        return 1;
    }
    
    String prevPattern = getPreviousPattern();
    if (prevPattern.length() == 0) {
        Serial.println("[ERROR] 没有可用的上一个图案");
        return 1;
    }
    
    if (patternLoader->loadPattern(prevPattern)) {
        Serial.printf("[PATTERN] 上一个图案已加载: %s\n", prevPattern.c_str());
        // 🔧 修复：不自动重置状态，让调用者决定状态转换
        return 0;
    } else {
        Serial.printf("[ERROR] 上一个图案加载失败: %s\n", prevPattern.c_str());
        return 2;
    }
}

int CommandExecutor::executeNextCommand() {
    Serial.println("🔄 执行下一个图案命令...");
    
    // 🔧 修复：添加命令互斥保护
    if (!preExecuteCheck("next")) {
        return 1;
    }
    
    // 🔧 修复：图案切换命令应该清除旧的暂停状态，从新图案的开头开始绘图
    Serial.println("🔄 清除旧图案的暂停状态，准备从新图案开头开始绘图");
    *isDrawingActive = false;
    *isDrawingPaused = false;
    *pausedAtIndex = -1;
    
    // 加载下一个图案
    int loadResult = loadNextPattern();
    if (loadResult != 0) {
        postExecuteProcess("next", loadResult);
        return loadResult;
    }
    
    Serial.println("✅ 下一个图案加载完成，调用 start 命令流程开始绘图...");
    
    // 🔧 修复：调用完整的 start 命令流程来执行绘图
    // 结束当前命令的互斥保护，让 start 命令可以正常执行
    markCommandEnd();
    
    // 直接调用 start 命令的核心逻辑，跳过归零（因为切换图案通常需要归零）
    int startResult = executeStartCommand(false);
    
    // start 命令内部已经处理了 postExecuteProcess，所以这里只返回结果
    return startResult;
}

int CommandExecutor::executePrevCommand() {
    Serial.println("🔄 执行上一个图案命令...");
    
    // 🔧 修复：添加命令互斥保护
    if (!preExecuteCheck("prev")) {
        return 1;
    }
    
    // 🔧 修复：图案切换命令应该清除旧的暂停状态，从新图案的开头开始绘图
    Serial.println("🔄 清除旧图案的暂停状态，准备从新图案开头开始绘图");
    *isDrawingActive = false;
    *isDrawingPaused = false;
    *pausedAtIndex = -1;
    
    // 加载上一个图案
    int loadResult = loadPreviousPattern();
    if (loadResult != 0) {
        postExecuteProcess("prev", loadResult);
        return loadResult;
    }
    
    Serial.println("✅ 上一个图案加载完成，调用 start 命令流程开始绘图...");
    
    // 🔧 修复：调用完整的 start 命令流程来执行绘图
    // 结束当前命令的互斥保护，让 start 命令可以正常执行
    markCommandEnd();
    
    // 直接调用 start 命令的核心逻辑，跳过归零（因为切换图案通常需要归零）
    int startResult = executeStartCommand(false);
    
    // start 命令内部已经处理了 postExecuteProcess，所以这里只返回结果
    return startResult;
}

int CommandExecutor::executeLoadCommand(const String& filename) {
    Serial.printf("🔄 执行加载图案命令: %s\n", filename.c_str());
    
    // 🔧 修复：添加命令互斥保护
    if (!preExecuteCheck("load")) {
        return 1;
    }
    
    // 加载指定图案
    int loadResult = loadPattern(filename);
    if (loadResult != 0) {
        postExecuteProcess("load", loadResult);
        return loadResult;
    }
    
    Serial.printf("✅ 图案 %s 加载完成，调用 start 命令流程开始绘图...\n", filename.c_str());
    
    // 🔧 修复：调用完整的 start 命令流程来执行绘图
    // 结束当前命令的互斥保护，让 start 命令可以正常执行
    markCommandEnd();
    
    // 直接调用 start 命令的核心逻辑，跳过归零（因为加载新图案通常需要归零）
    int startResult = executeStartCommand(false);
    
    // start 命令内部已经处理了 postExecuteProcess，所以这里只返回结果
    return startResult;
}

int CommandExecutor::executeListCommand() {
    Serial.println("=== 图案文件列表 ===");
    std::vector<String> patterns = getPatternList();
    
    if (patterns.empty()) {
        Serial.println("未找到图案文件");
        return 1;
    }
    
    for (size_t i = 0; i < patterns.size(); i++) {
        Serial.printf("%d. %s\n", i + 1, patterns[i].c_str());
    }
    
    Serial.printf("总计: %d 个图案文件\n", patterns.size());
    return 0;
}

int CommandExecutor::loadDefaultOrLastPattern() {
    // 🔧 修复：使用统一的图案索引管理，确保与next/prev命令联动
    if (!patternLoader) {
        Serial.println("[ERROR] PatternLoader未初始化");
        return 1;
    }
    
    Serial.println("🎨 加载默认或上次使用的图案（统一索引管理）...");
    
    String lastPattern = loadLastUsedPattern();
    
    if (lastPattern.length() > 0) {
        Serial.printf("[PATTERN] 尝试加载上次使用的图案: %s\n", lastPattern.c_str());
        if (loadPattern(lastPattern) == 0) {
            Serial.printf("[PATTERN] ✅ 已加载上次使用的图案: %s\n", lastPattern.c_str());
            // 🔧 关键修复：确保PatternLoader的currentPatternName正确设置
            if (patternLoader->getCurrentPatternName() != lastPattern) {
                Serial.printf("[DEBUG] 修正图案名称: %s -> %s\n", 
                              patternLoader->getCurrentPatternName().c_str(), lastPattern.c_str());
            }
            return 0;
        } else {
            Serial.printf("[PATTERN] ⚠️ 上次使用的图案加载失败: %s\n", lastPattern.c_str());
        }
    }
    
    // 如果没有上次使用的图案或加载失败，使用图案列表的第一个
    std::vector<String> patterns = getPatternList();
    if (!patterns.empty()) {
        String defaultPattern = patterns[0];
        Serial.printf("[PATTERN] 尝试加载默认图案: %s\n", defaultPattern.c_str());
        if (loadPattern(defaultPattern) == 0) {
            Serial.printf("[PATTERN] ✅ 已加载默认图案: %s (列表索引: 0)\n", defaultPattern.c_str());
            // 🔧 关键修复：确保PatternLoader的currentPatternName正确设置
            if (patternLoader->getCurrentPatternName() != defaultPattern) {
                Serial.printf("[DEBUG] 修正图案名称: %s -> %s\n", 
                              patternLoader->getCurrentPatternName().c_str(), defaultPattern.c_str());
            }
            return 0;
        } else {
            Serial.printf("[PATTERN] ❌ 默认图案加载失败: %s\n", defaultPattern.c_str());
        }
    }
    
    Serial.println("[ERROR] 无可用图案");
    return 1;
}

bool CommandExecutor::saveLastUsedPattern(const String& patternName) {
    if (preferences) {
        preferences->begin("patterns", false);
        preferences->putString("last_used", patternName);
        preferences->end();
        return true;
    }
    return false;
}

String CommandExecutor::loadLastUsedPattern() {
    if (preferences) {
        preferences->begin("patterns", true);
        String lastPattern = preferences->getString("last_used", "");
        preferences->end();
        return lastPattern;
    }
    return "";
}

// ==================== LED控制实现 ====================

int CommandExecutor::enableWS2812() {
    if (ledControlCenter) {
        ledControlCenter->enableWS2812(true);
        Serial.println("[LED] WS2812灯带已启用");
        return 0;
    }
    return 1;
}

int CommandExecutor::disableWS2812() {
    if (ledControlCenter) {
        ledControlCenter->enableWS2812(false);
        Serial.println("[LED] WS2812灯带已禁用");
        return 0;
    }
    return 1;
}

int CommandExecutor::setBrightness(int brightness) {
    if (brightness < 0 || brightness > 255) {
        Serial.println("[ERROR] 亮度范围: 0-255");
        return 1;
    }
    
    if (ledControlCenter) {
        ledControlCenter->setGlobalBrightness(brightness);
        Serial.printf("[LED] 全局亮度设置为: %d\n", brightness);
        return 0;
    }
    return 1;
}

int CommandExecutor::setDrawingEffect(int effectId) {
    if (ledControlCenter) {
        // 这里需要将effectId转换为LEDEffectMode
        LEDEffectMode mode = static_cast<LEDEffectMode>(effectId);
        ledControlCenter->setDrawingEffect(mode, {255, 0, 0}); // 默认红色
        Serial.printf("[LED] 绘图效果设置为: %d\n", effectId);
        return 0;
    }
    return 1;
}

int CommandExecutor::setDrawingColor(int r, int g, int b) {
    if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
        Serial.println("[ERROR] 颜色范围: 0-255");
        return 1;
    }
    
    if (ledControlCenter) {
        LEDColor color = {static_cast<uint8_t>(r), static_cast<uint8_t>(g), static_cast<uint8_t>(b)};
        ledControlCenter->setDrawingEffect(EFFECT_SOLID, color);
        Serial.printf("[LED] 绘图颜色设置为: R=%d G=%d B=%d\n", r, g, b);
        return 0;
    }
    return 1;
}

int CommandExecutor::setDrawingBrightness(int brightness) {
    if (brightness < 0 || brightness > 255) {
        Serial.println("[ERROR] 亮度范围: 0-255");
        return 1;
    }
    
    if (ledControlCenter) {
        ledControlCenter->setDrawingBrightness(brightness);
        Serial.printf("[LED] 绘图亮度设置为: %d\n", brightness);
        return 0;
    }
    return 1;
}

int CommandExecutor::setDrawingEffectSpeed(int speed) {
    if (speed < 1 || speed > 10) {
        Serial.println("[ERROR] 速度范围: 1-10");
        return 1;
    }
    
    if (ledControlCenter) {
        ledControlCenter->setDrawingSpeed(speed);
        Serial.printf("[LED] 绘图效果速度设置为: %d\n", speed);
        return 0;
    }
    return 1;
}

int CommandExecutor::setGlobalBrightness(int brightness) {
    return setBrightness(brightness);
}

int CommandExecutor::enableLED(bool enable) {
    if (enable) {
        return enableWS2812();
    } else {
        return disableWS2812();
    }
}

String CommandExecutor::getLEDStatus() {
    if (ledControlCenter) {
        LEDStatus status = ledControlCenter->getCurrentStatus();
        switch (status) {
            case LED_OFF: return "关闭";
            case LED_STARTUP: return "启动中";
            case LED_INITIALIZING: return "初始化中";
            case LED_WIFI_CONNECTING: return "WiFi连接中";
            case LED_WIFI_CONNECTED: return "WiFi已连接";
            case LED_WIFI_FAILED: return "WiFi连接失败";
            case LED_IDLE: return "待机";
            case LED_HOMING: return "归零中";
            case LED_DRAWING: return "绘图中";
            case LED_PAUSED: return "暂停";
            case LED_COMPLETED: return "完成";
            case LED_ERROR: return "错误";
            case LED_MAINTENANCE: return "维护";
            case LED_EMERGENCY: return "紧急停止";
            default: return "未知";
        }
    }
    return "LED控制器未初始化";
}

// ==================== 帮助信息实现 ====================

int CommandExecutor::executeHelpCommand() {
    Serial.println("\n=== ESP32沙画机命令帮助 ===");
    Serial.println("绘图控制:");
    Serial.println("  start - 开始绘图");
    Serial.println("  stop/pause - 停止/暂停绘图");
    Serial.println("  home - 归零操作");
    Serial.println("  sweep - 扫图整理");
    Serial.println();
    Serial.println("图案切换:");
    Serial.println("  next - 下一个图案");
    Serial.println("  prev - 上一个图案");
    Serial.println("  load <文件名> - 加载指定图案");
    Serial.println("  list - 显示图案列表");
    Serial.println();
    Serial.println("扫图模式:");
    Serial.println("  sweepprep - 扫图并准备绘图");
    Serial.println("  sweepnext - 扫图并切换到下一个图案");
    Serial.println("  sweepprev - 扫图并切换到上一个图案");
    Serial.println();
    Serial.println("系统查询:");
    Serial.println("  status - 系统状态");
    Serial.println("  info - 设备信息");
    Serial.println("  position - 当前位置");
    Serial.println("  help - 显示此帮助");
    Serial.println();
    Serial.println("电机控制:");
    Serial.println("  enable - 启用电机");
    Serial.println("  disable - 禁用电机");
    Serial.println("  timeout <秒数> - 设置电机空闲超时时间");
    Serial.println();
    Serial.println("LED控制:");
    Serial.println("  ledon - 启用LED灯带");
    Serial.println("  ledoff - 禁用LED灯带");
    Serial.println("  brightness <0-255> - 设置亮度");
    Serial.println("  drawcolor <R> <G> <B> - 设置绘图颜色");
    Serial.println("=========================\n");
    return 0;
}

// ==================== 内存信息实现 ====================

int CommandExecutor::executeMemInfoCommand() {
    Serial.println("[MEMORY] === 内存使用情况 ===");
    Serial.printf("[MEMORY] 可用内存: %d bytes (%.1f KB)\n", 
        ESP.getFreeHeap(), ESP.getFreeHeap() / 1024.0);
    Serial.printf("[MEMORY] 总内存: %d bytes (%.1f KB)\n", 
        ESP.getHeapSize(), ESP.getHeapSize() / 1024.0);
    Serial.printf("[MEMORY] 内存使用率: %.1f%% (%d bytes 已使用)\n", 
        (float)(ESP.getHeapSize() - ESP.getFreeHeap()) / ESP.getHeapSize() * 100.0,
        ESP.getHeapSize() - ESP.getFreeHeap());
    Serial.printf("[MEMORY] 历史最小可用: %d bytes (%.1f KB)\n", 
        ESP.getMinFreeHeap(), ESP.getMinFreeHeap() / 1024.0);
    return 0;
}
